Finally finished. However, I'm finding that triggering breakpoints and stepping through breakpoints is taking 2-3 seconds per breakpoint. Which is insane.

I enabled the arguments/environment-variables to debug what the sqllite database was doing behind the scenes, and now I'm even more confused. TraceSQL(0x127e12970): INSERT INTO ZVARIANTMODEL( Z_PK, Z_ENT, Z_OPT, ZPROJECT, ZTHUMBNAIL, Z2VARIANTS, ZASSIGNMENTS, ZELEMENTGROUPS, ZGROUPEDELEMENTS, ZID, ZMODIFIEDON, ZNAME, ZSWATCHES ) VALUES( 1, 4, 1, NULL, NULL, 1, x'7b7d', NULL, NULL, x'31ddf4ce24b8463e9ede5bfe4457e19e', 718570686.400954, 'Super Long', x'62706c697374303...00000000000005f' ) If I'm reading this correctly, it appears to be storing ZELEMENTGROUPS and ZGROUPEDELEMENTS which are the internal stored values on the Group type. I would have assumed it would instead just use whatever implementation I have for Codable? It is storing nil for both of these types. This seems very odd, and not what I would expect at all.

I managed to get the edit menu working with the following code. class MyARView: ARView, UIEditMenuInteractionDelegate { private var editMenuInteraction: UIEditMenuInteraction? = nil required init(frame frameRect: CGRect) { super.init(frame: frameRect) setupEditMenu() } required dynamic init?(coder decoder: NSCoder) { super.init(coder: decoder) setupEditMenu() } override init(frame frameRect: CGRect, cameraMode: ARView.CameraMode, automaticallyConfigureSession: Bool) { super.init(frame: frameRect, cameraMode: cameraMode, automaticallyConfigureSession: automaticallyConfigureSession) setupEditMenu() } func isValidHitTest(at location: CGPoint) -> Bool { // TODO: Implement... // return true } func setupEditMenu() { print("Hello, world!") editMenuInteraction = UIEditMenuInteraction(delegate: self) if let editMenuInteraction { self.addInteraction(editMenuInteraction) } let longPressGestureRecognizer = UILongPressGestureRecognizer(target: self, action: #selector(handleLongPress(_:))) self.addGestureRecognizer(longPressGestureRecognizer) } func editMenuInteraction(_ interaction: UIEditMenuInteraction, menuFor configuration: UIEditMenuConfiguration, suggestedActions: [UIMenuElement]) -> UIMenu? { UIMenu( title: "", options: .displayInline, children: [ UIAction(title: "Menu Option") { _ in print("Do the thing") } ] ) } @objc func handleLongPress(_ gestureRecognizer: UILongPressGestureRecognizer) { guard gestureRecognizer.state == .began else { return } let location = gestureRecognizer.location(in: self) guard isValidHitTest(at: location) else { return } let configuration = UIEditMenuConfiguration(identifier: "MyARView", sourcePoint: location) editMenuInteraction?.presentEditMenu(with: configuration) } }

Actually I see this is possible by binding to the Opacity BindTarget. But assume I have something other than an OpacityComponent - how would one target a property on a component?

No there isn't I'm afraid. You have to convert to Data. I would caution against using loadTransferable as the Transferable type is intended to short term storage (copy and paste, drag and drop...etc), and there is no guarantee how that API may change in the future. If you're storing data for extended periods, you should try and ensure consistency of the kind of data stored. In our app, we have a generic SwiftData entity for storing an image. Any other entity that wants to store an image can maintain a relationship to one of these entities. It saves us having to add logic everywhere we want to store images. The generic image entity takes an NSImage, UIImage or CGImage and grabs the data in PNG format and stores it in the model. Then extensions on those types to initialise them directly from the SwiftData entity. It makes things a little cleaner, but it's essentially the same thing, especially considering we store images in multiple places in our model. An extension on NSImage to get the PNG data. extension NSImage { /// Returns the PNG data for the `NSImage` as a Data object. /// /// - Returns: A data object containing the PNG data for the image, or nil /// in the event of failure. /// public func pngData() -> Data? { guard let cgImage = self.cgImage(forProposedRect: nil, context: nil, hints: nil) else { return nil } let bitmapRepresentation = NSBitmapImageRep(cgImage: cgImage) return bitmapRepresentation.representation(using: .png, properties: [:]) } } The basic data model for our image. We store a type and some data which is the PNG data. @Model final class ImageModel { /// The type of the image. /// /// We use different images for different things, so storing an image type /// lets us differentiate use. /// var type: ImageType = ImageType.unknown /// The image data, stored as a PNG. /// /// It is tagged with externalStorage to allow the large binary data to be stored /// externally. /// @Attribute(.externalStorage) var pngData: Data? = nil /// Initialize the image model. /// /// - Parameters: /// - type: The type of image the image model represents. /// - pngData: The image data in png format. /// init(type: ImageType, pngData: Data) { self.type = type self.pngData = pngData } #if canImport(AppKit) import AppKit /// Initialize the image model from an `NSImage`. /// /// - Parameters: /// - type: The type of the image the image model represents. /// - image: The `NSImage` to store in the image model. /// convenience init(type: ImageType, image: NSImage) throws { guard let pngData = image.pngData() else { throw GenericError.failed("Unable to get PNG data for image") } self.init(type: type, pngData: pngData) } #elseif canImport(UIKit) import UIKit /// Initialize the image model from a `UIImage`. /// /// - Parameters: /// - type: The type of the image the image model represents. /// - image: The `UIImage` to store in the image model. /// convenience init(type: ImageType, image: UIImage) throws { guard let pngData = image.pngData() else { throw GenericError.failed("Unable to get PNG data for image") } self.init(type: type, pngData: pngData) } #endif } Given an ImageModel, initialises a UIImage or NSImage from the data stored in the model. #if canImport(UIKit) import UIKit extension UIImage { /// Initialize a new `UIImage` using data from an `ImageModel`. /// /// - Parameters: /// - model: The image model to load the image from. /// convenience init?(loadingDataFrom model: ImageModel) { guard let data = model.pngData, data.isEmpty == false else { return nil } self.init(data: data) } } #elseif canImport(AppKit) import AppKit extension NSImage { /// Initialize a new `NSImage` using data from an `ImageModel`. /// /// - Parameters: /// - model: The image model to load the image from. /// convenience init?(loadingDataFrom model: ImageModel) { guard let data = model.pngData, data.isEmpty == false else { return nil } self.init(data: data) } } #endif

I assume you cannot modify the API entirely? If you have full control, you can simply do something like: func doWork(_ someValue) async { // Long time of work } If you still want to maintain the completion handler API, but wrap it with an async version, you should take a look at Continuations. There's an article on hackingwithswift.com that might help: https://www.hackingwithswift.com/quick-start/concurrency/how-to-use-continuations-to-convert-completion-handlers-into-async-functions. Using this approach, your existing function could be wrapped by a new async version quite easily. func doWork(_ someValue: Int, completionHandler: @escaping () -> Void) { let q = DispatchQueue(label: "MyLabel") q.async { // Long time of work completionHandler() } } func doWork(_ someValue: Int) async { await withCheckedContinuation { continuation in // Call the existing completion handler API. doWork(someValue) { // Resume the continuation to exit the async function. continuation.resume() } } } Care should be taken to ensure you always call the completion handler in the original API, otherwise you could have a situation where your continuation doesn't resume. You know you've usually done this if you see something like this in the console: SWIFT TASK CONTINUATION MISUSE: doWork(_:) leaked its continuation!. Continuations can return values, and even throw errors if needed. If you're curious about other functions, you can often use Xcode to refactor the function to be asynchronous, or generate an async wrapper (although mileage may vary depending on the function complexity). You can do this by selecting the function name, right clicking and choosing "Refactor", and then picking either "Convert Function to Async" or "Add Async Wrapper". The code generated from "Add Async Wrapper" is as follows, which isn't far from the example above: @available(*, renamed: "doWork(_:)") func doWork(_ someValue: Int, completionHandler: @escaping () -> Void) { let q = DispatchQueue(label: "MyLabel") q.async { // Long time of work completionHandler() } } func doWork(_ someValue: Int) async { return await withCheckedContinuation { continuation in doWork(someValue) { continuation.resume(returning: ()) } } } Hope that helps. -Matt

Yes, as jlilest states, disabled isn't available on macOS for whatever reason. You are correct that MenuActionDismissBehavior is available on macOS 13.3+, but the dismiss behaviour disabled is not supported on macOS: https://developer.apple.com/documentation/swiftui/menuactiondismissbehavior/disabled

Also interested in this. Experience with the device so far has required a cable to connect to a Mac, but the devices we've ordered don't appear to have the cable. I'm really hoping it isn't wireless debugging only, because despite being improved in Xcode 15, wireless debugging is still extremely slow and a painful experience. Something as big as a VisionPro headset should really have an option to connect a cable - it's not a watch.

I am curious why Reality Composer Pro is exporting a displacement map, as my understand was that RealityKit doesn't support Displacement maps for PBR textures. Was this for a surface shader? If you're asking about EXR, this is the OpenEXR file format: https://openexr.com. It is essentially a high-dynamic range image format stored in a linear format. For example, it can store values greater than 0.0...1.0, which are not usually possible with low-dynamic range formats such as JPEG. Additionally, unlike image formats that store in a non-linear colorspace such as Adobe RGB, linear colorspace means that the numerical intensity of a pixel correspond proportionally to their perceived intensity, in other words a value of 0.5 is half as intense/bright as a value of 1.0, and a quarter as intense/bright as a value of 2.0...etc. This is not the case with non-linear colorspaces that are often found in formats such as JPEG. EXR is often used as the image format for USD because they are both open source formats that originated in the visual effects community. You should be able to open EXR files with either Xcode, or the Preview app on macOS.

Loading as an Entity instead of a ModelEntity will stop the model being collapsed into a single layer, but beware as Entity.load is blocking, and you'd be much better off using the Entity(named:in:) async throws initialiser, as it's asynchronous. For example: RealityView { content in do { let chessPiecesEntity = try await Entity(named: "ChessPiecesModel") guard let chessPiecesModelEntity = chessPiecesEntity as? ModelEntity else { throw Some.error } // Prepare the model entity if you need to set materials. content.add(chessPiecesEntity) } catch { print(error.localizedDescription) } }

The level of immersion is controlled by the immersionStyle view modifier applied to the ImmersiveSpace. The supported levels of immersion are mixed, progressive and full. More information can be found on the supported immersion styles here: https://developer.apple.com/documentation/swiftui/immersionstyle. In short, the mixed immersion style means you can show your content in the real world; the progressive immersion style allows a background to be placed to occlude parts of the real world, with the user turning the Digital Crown to control the level of immersion; and finally full immersion which uses your content to fully occlude the real world. As you can imagine, the progressive mode used by the Destination Video app means that the video partially occludes the world, but doesn't cover the full 360 degrees around the user by default. You can change this behaviour by opening the DestinationVideo.swift file in the project (where the @main entry point is defined), and replacing the following code: .immersionStyle(selection: .constant(.progressive), in: .progressive) with... .immersionStyle(selection: .constant(.full), in: .full) However, unless you need to enforce a full immersion, for example for the purposes of a game, it is perhaps better to support progressive immersion and allow the user to decide by turning the Digital Crown to control the level of immersion. For more information, I'd suggest the WWDC 23 session "Getting started with building apps for spatial computing".

As you can see from the error Xcode/Playgrounds is providing, the problem here is that your function getElements() is expecting to return a UIImage, yet you are returning a String. Additionally, the initialiser UIImage(named:) is expecting a string, but you're passing in an image. This can be fixed in one of two ways: 1 - Rewrite the getElements() function actually return a UIImage. Of course this will likely have to be an optional, as randomElement() returns an optional element to handle cases where the array is empty. func getElements() -> UIImage? { let elements = ["rectangle", "circle", "triangle"] guard let randomElement = elements.randomElement() else { return nil } return UIImage(named: randomElement) } And then at the point of usage, you can just do something like: cell.contents = getElements()?.cgImage 2 - Alternatively, you could update your function getElements() to return a string. This is basically the same, but it moves the logic to test the optional to outside of the getElements() function. func getElements() -> String? { let elements = ["rectangle", "circle", "triangle"] return elements.randomElement() } And then at the point of usage, you have to test the optional, and use it to initialise the image: if let element = getElements() { cell.contents = UIImage(named: element)?.cgImage } Personally, I prefer option one, as it removes the burden of checking the nil string from the point of usage. But it all depends on what you're trying to achieve. I would also perhaps consider renaming the function to something like randomImage(), as getElements() is perhaps a little unclear, but that's just personal preference. Hope that helps.

There's usually no feedback until you're either rejected or accepted. Upon approval, you will receive an email to the addresses associated with your developer account with the subject "Your submission was accepted". When you're rejected, or App Store review encounter an issue, you'll usually receive an email with the subject "We noticed an issue with your submission". Then you need to visit App Store Connect and read the messages to work out what the problem is, but they're usually not that descriptive. Generally though, once you throw it over the wall to Apple, it's a waiting game until you're hear back.

What's your question exactly?

Apple support have informed me that despite being for different platforms, as the apps have the same SKU and the VisionOS app is already for sale, the iOS version cannot be made for presale. Disappointing, but understandable.